package Study2;


import java.util.Scanner;

class Tests {
    public int num = 100;
}

// 自定义异常类
class MyException extends RuntimeException {
    public MyException() {
        super();  // 调用父类的无参构造方法
    }

    public MyException(String message) {
        super(message);   // 调用父类的有参构造方法
    }

}
public class Study29 {
    // 自定义抛出异常,throws 声明自定义异常类
    public static void demo(int x) throws MyException{
        if( 10 == x) {
            // 抛出自定义异常类
            throw new MyException("x 不可以等于 10 ");
        }
        System.out.println(x);
    }

    public static void main(String[] args) {
        try {
            demo(10);
        } catch (MyException e) {
//            e.printStackTrace();
            System.out.println("处理自定类型的异常");
        } finally {
            System.out.println("一定会被执行");
        }
        System.out.println("hello world");
    }


    public static int  division(int x, int y) throws ArithmeticException {
       if( 0 == y) {  // 根据自定义条件，满足，
           throw new ArithmeticException("分母不可以为 0");
           /* 你可以省略提示调用构造方法,如下
           throw new ArithmeticException();
            */
       }
       return x / y;

    }
    public static void main11(String[] args) {

        try {
            int ret = division(20,0);
            System.out.println(ret);
        } catch( ArithmeticException e) {
            System.out.println("捕获到算术异常");
        } finally {
            System.out.println("一点会被执行");
        }

    }

    public static void main10(String[] args)  {
        division(20 ,0);  // 出现异常，调用者没有异常处理,终止程序
      /*  try {
            division();
        } catch (ArithmeticException e) {
            e.printStackTrace();
            System.out.println("捕获到算术异常");
        }finally {
           System.out.println("一定会被执行");
        }*/
        System.out.println("hello world");

    }


    public static int test() {
        int[] array = {1,2,3};
        try {
            System.out.println(array[5]);
            return 0;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常");
            return 2;
        } finally {
            System.out.println("无论是否出现异常 finally有代码块中的语句一定会被执行");
            return 1;
        }
    }
    public static void main9(String[] args) {
        int ret = test();
        System.out.println(ret);
    }


    public static void main8(String[] args) {
        int[] array = {1,2,3};

        try {
            System.out.println(array[5]);
            System.out.println("上面出现了异常，这条语句不会被执行");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常");
        } finally {
            System.out.println("无论是否出现异常 finally有代码块中的语句一定会被执行");
        }
        System.out.println("hello world");
    }

    public static void main7(String[] args) {
        int[] array = {1,2,3};

        try {
            System.out.println(array[5]);
        } catch(Exception e) {  // 捕获异常
            e.printStackTrace();   // 爆红，提示出现异常的代码的位置
            System.out.println("捕获到Exception异常");
        } /*catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常");
        }
*/
        System.out.println("hello world");
    }


    public static void main6(String[] args) {
        int[] array = {1,2,3};
        System.out.println(array[5]);
        System.out.println("hello world");
    }

    // 异常处理
    public static void main5(String[] args) {
        int[] array = {1,2,3};

        try {    // 抛出代码可能出现的异常的方法，操作
            System.out.println(array[5]);
        } catch (ArrayIndexOutOfBoundsException e) {  // 捕获到 try抛出的数组越界异常 catch捕获到该异常，e 形参类型是类类型
            // e 可以说是该异常类型的实例引用
            System.out.println(e);
            e.printStackTrace();     // 爆红，提醒出现异常代码的位置
            System.out.println("数组越界异常");
        }

        System.out.println("hello world ");
    }





    // 栈溢出异常
    public static void func() {
        func();
    }
    public static void main4(String[] args) {
        func();
    }


    // null 引用访问
    public static void main3(String[] args) {
        Tests tests = null;
        System.out.println(tests.num);


    }


    // 数组越界异常
    public static void main2(String[] args) {
        int[] array = {1,2,3};
        System.out.println(array[5]);
    }


    // 算术异常
    public static void main1(String[] args) {
        System.out.println(10/0);
    }
}
